<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="shortcut icon" type="image/x-icon" href="/favicon.ico">
<script>MathJax = {tex: {inlineMath: [["\\(", "\\)"]]}, svg: {fontCache: "global"}};</script>
<script type="text/javascript" id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js"></script>
<link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/11.4.0/styles/default.min.css">
<script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/11.4.0/highlight.min.js"></script>
<script>hljs.highlightAll();</script>
<script src="../static/mccole.js"></script>
<script>window.onload = () => fixPage()</script>

    <script defer data-domain="stjs.tech" src="https://plausible.io/js/plausible.js"></script>

    <link href="../static/mccole.css" rel="stylesheet" type="text/css">
    <title>Software Design by Example: <h1 id="glossary">Glossary</h1></title>
  </head>
  <body>
    <main>
      <p class="home"><a href="../">Software Design by Example</a></p>
      <h1 id="glossary">Glossary</h1>
      <dl>
<dt><span class="glosskey" id="absolute_error">absolute error</span></dt>
<dd>The absolute value of the difference between the observed and the correct value. Absolute error is usually less useful than <a href="#relative_error">relative error</a>.</dd>
<dt><span class="glosskey" id="absolute_path">absolute path</span></dt>
<dd>A path that points to the same location in the <a href="#filesystem">filesystem</a> regardless of where it is evaluated. An absolute path is the equivalent of latitude and longitude in geography.
<br/>See also: <a href="#relative_path">relative path</a>.</dd>
<dt><span class="glosskey" id="abstract_method">abstract method</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a <a href="#method">method</a> that is defined but not implemented. Programmers will define an abstract method in a <a href="#parent_class">parent class</a> to specify operations that <a href="#child_class">child classes</a> must provide.</dd>
<dt><span class="glosskey" id="abstract_syntax_tree">abstract syntax tree</span> (AST)</dt>
<dd>A deeply nested data structure, or <a href="#tree">tree</a>, that represents the structure of a program. For example, the AST might have a <a href="#node">node</a> representing a <code>while</code> loop with one <a href="#child_tree">child</a> representing the loop condition and another representing the <a href="#loop_body">loop body</a>.</dd>
<dt><span class="glosskey" id="accidental_complexity">accidental complexity</span></dt>
<dd>The extra (avoidable) complexity introduced by poor design choices. The term is used in contrast with <a href="#intrinsic_complexity">intrinsic complexity</a>.</dd>
<dt><span class="glosskey" id="accumulator">accumulator</span></dt>
<dd>A variable that collects and/or combines many values.  For example, if a program sums the values in an array by adding them all to a variable called <code>result</code>, then <code>result</code> is the accumulator.</dd>
<dt><span class="glosskey" id="actual_result">actual result (of test)</span></dt>
<dd>The value generated by running code in a test. If this matches the <a href="#expected_result">expected result</a>, the test <a href="#pass_test">passes</a>; if the two are different, the test <a href="#fail_test">fails</a>.</dd>
<dt><span class="glosskey" id="adapter_pattern">Adapter pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> that rearranges parameters, provides extra values, or does other work so that one function can be called by another.</dd>
<dt><span class="glosskey" id="alias">alias</span></dt>
<dd>A second or subsequent reference to the same object. Aliases are useful, but increase the <a href="#cognitive_load">cognitive load</a> on readers who have to remember that all these names refer to the same thing.</dd>
<dt><span class="glosskey" id="anonymous_function">anonymous function</span></dt>
<dd>A function that has not been assigned a name. Anonymous functions are usually quite short, and are usually defined where they are used, e.g., as callbacks. In Python, these are called lambda functions and are created through use of the lambda reserved word.</dd>
<dt><span class="glosskey" id="abi">Application Binary Interface</span> (ABI)</dt>
<dd>The low-level layout that a piece of software must have to work on a particular kind of machine.</dd>
<dt><span class="glosskey" id="api">Application Programming Interface</span> (API)</dt>
<dd>A set of functions provided by a software library or web service that other software can call.</dd>
<dt><span class="glosskey" id="argument">argument</span></dt>
<dd>A value passed to a function when it is called.
<br/>See also: <a href="#parameter">parameter</a>.</dd>
<dt><span class="glosskey" id="ascii">ASCII</span></dt>
<dd>A standard way to represent the characters commonly used in the Western European languages as 7- or 8-bit integers, now largely superceded by <a href="#unicode">Unicode</a>.</dd>
<dt><span class="glosskey" id="assembler">assembler</span></dt>
<dd>A <a href="#compiler">compiler</a> that translates software written in <a href="#assembly_code">assembly code</a> into machine instructions.
<br/>See also: <a href="#disassembler">disassembler</a>.</dd>
<dt><span class="glosskey" id="assembly_code">assembly code</span></dt>
<dd>A low-level programming language whose statements correspond closely to the actual <a href="#instruction_set">instruction set</a> of a particular kind of processor.</dd>
<dt><span class="glosskey" id="assertion">assertion</span></dt>
<dd>A <a href="#boolean">Boolean</a> expression that must be true at a certain point in a program. Assertions may be built into the language (e.g., Python's <code>assert</code> statement) or provided as functions (as with Node's <code>assert</code> library).</dd>
<dt><span class="glosskey" id="associative_array">associative array</span></dt>
<dd>See <a href="#dictionary">dictionary</a>.</dd>
<dt><span class="glosskey" id="asynchronous">asynchronous</span></dt>
<dd>Not happening at the same time. In programming, an asynchronous operation is one that runs independently of another, or that starts at one time and ends at another.
<br/>See also: <a href="#synchronous">synchronous</a>.</dd>
<dt><span class="glosskey" id="attribute">attribute</span></dt>
<dd>A name-value pair associated with an object, used to store metadata about the object such as an array's dimensions.</dd>
<dt><span class="glosskey" id="automatic_variable">automatic variable</span></dt>
<dd>A variable that is automatically given a value in a <a href="#build_rule">build rule</a>. For example, Make automatically assigns the name of a rule's <a href="#build_target">target</a> to the automatic variable <code>$@</code>. Automatic variables are frequently used when writing <a href="#pattern_rule">pattern rules</a>.
<br/>See also: <a href="#makefile">Makefile</a>.</dd>
<dt><span class="glosskey" id="backward_compatible">backward-compatible</span></dt>
<dd>A property of a system that enables interoperability with an older legacy system, or with input designed for such a system.</dd>
<dt><span class="glosskey" id="bare_object">bare object</span></dt>
<dd>An object that isn't an instance of any particular class.</dd>
<dt><span class="glosskey" id="base_class">base class</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a <a href="#class">class</a> from which other classes are derived.
<br/>See also: <a href="#child_class">child class</a>, <a href="#derived_class">derived class</a>, <a href="#parent_class">parent class</a>.</dd>
<dt><span class="glosskey" id="binary">binary</span></dt>
<dd>A system which can have one of two possible states, often represented as 0 and 1 or true and false.</dd>
<dt><span class="glosskey" id="bit">bit</span></dt>
<dd>A single binary digit (0 or 1).
<br/>See also: <a href="#binary">binary</a>, <a href="#boolean">Boolean</a>.</dd>
<dt><span class="glosskey" id="bitwise_operation">bitwise operation</span></dt>
<dd>An operation that manipulates individual bits in memory. Common bitwise operations include <code>and</code>, <code>or</code>, <code>not</code>, and <code>xor</code>.</dd>
<dt><span class="glosskey" id="block_comment">block comment</span></dt>
<dd>A <a href="#comment">comment</a> that spans multiple lines. Block comments may be marked with special start and end symbols, like <code>/*</code> and <code>*/</code> in C and its descendents, or each line may be prefixed with a marker like <code>#</code>.</dd>
<dt><span class="glosskey" id="boolean">Boolean</span></dt>
<dd>Relating to a variable or data type that can have either a logical value of true or false. Named for George Boole, a 19th century mathematician.</dd>
<dt><span class="glosskey" id="breadth_first">breadth first</span></dt>
<dd>To go through a nested data structure such as a <a href="#tree">tree</a> by exploring all of one level, then going on to the next level and so on, or to explore a problem by examining the first step of each possible solution, and then trying the next step for each.
<br/>See also: <a href="#depth_first">depth-first</a>.</dd>
<dt><span class="glosskey" id="breakpoint">breakpoint</span></dt>
<dd>An instruction to a debugger telling it to suspend execution whenever a specific point in the program (such as a particular line) is reached.
<br/>See also: <a href="#watchpoint">watchpoint</a>.</dd>
<dt><span class="glosskey" id="bug">bug</span></dt>
<dd>A missing or undesirable <a href="#feature_software">feature</a> of a piece of software.</dd>
<dt><span class="glosskey" id="build_manager">build manager</span></dt>
<dd>A program that keeps track of how files depend on one another and runs commands to update any files that are out-of-date. Build managers were invented to <a href="#compile">compile</a> only those parts of programs that had changed, but are now often used to implement workflows in which plots depend on results files, which in turn depend on raw data files or configuration files.
<br/>See also: <a href="#build_rule">build rule</a>, <a href="#dependency">dependency</a>, <a href="#makefile">Makefile</a>.</dd>
<dt><span class="glosskey" id="build_recipe">build recipe</span></dt>
<dd>The part of a <a href="#build_rule">build rule</a> that describes how to update something that has fallen out-of-date.</dd>
<dt><span class="glosskey" id="build_rule">build rule</span></dt>
<dd>A specification for a <a href="#build_manager">build manager</a> that describes how some files depend on others and what to do if those files are out-of-date.</dd>
<dt><span class="glosskey" id="build_target">build target</span></dt>
<dd>The file(s) that a <a href="#build_rule">build rule</a> will update if they are out-of-date compared to their <a href="#dependency">dependencies</a>.
<br/>See also: <a href="#makefile">Makefile</a>.</dd>
<dt><span class="glosskey" id="byte_code">byte code</span></dt>
<dd>A set of instructions designed to be executed efficiently by an <a href="#interpreter">interpreter</a>.</dd>
<dt><span class="glosskey" id="cache">cache</span></dt>
<dd>Something that stores copies of data so that future requests for it can be satisfied more quickly. The CPU in a computer uses a hardware cache to hold recently-accessed values; many programs rely on a software cache to reduce network traffic and latency. Figuring out when something in a cache is out-of-date and should be replaced is one of the <a href="#two_hard_problems">two hard problems in computer science</a>.</dd>
<dt><span class="glosskey" id="caching">caching</span></dt>
<dd>To save a copy of some data in a local <a href="#cache">cache</a> to make future access faster.</dd>
<dt><span class="glosskey" id="call_stack">call stack</span></dt>
<dd>A data structure that stores information about the active subroutines executed.</dd>
<dt><span class="glosskey" id="callback">callback function</span></dt>
<dd>A function A that is passed to another function B so that B can call it at some later point. Callbacks can be used <a href="#synchronous">synchronously</a>, as in generic functions like <code>map</code> that invoke a callback function once for each element in a collection, or <a href="#asynchronous">asynchronously</a>, as in a <a href="#client">client</a> that runs a callback when a <a href="#http_response">response</a> is received in answer to a <a href="#http_request">request</a>.</dd>
<dt><span class="glosskey" id="css">Cascading Style Sheets</span> (CSS)</dt>
<dd>A way to control the appearance of HTML. CSS is typically used to specify fonts, colors, and layout.</dd>
<dt><span class="glosskey" id="catch_exception">catch (an exception)</span></dt>
<dd>To handle an error or other unexpected event represented by an <a href="#exception">exception</a>.</dd>
<dt><span class="glosskey" id="chain_of_responsibility_pattern">Chain of Responsibility pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> in which each <a href="#object">object</a> either handles a request or passes it on to another object.</dd>
<dt><span class="glosskey" id="character_encoding">character encoding</span></dt>
<dd>A specification of how characters are stored as bytes. The most commonly-used encoding today is <a href="#utf_8">UTF-8</a>.</dd>
<dt><span class="glosskey" id="child_tree">child (in a tree)</span></dt>
<dd>A <a href="#node">node</a> in a <a href="#node">tree</a> that is below another node (call the <a href="#parent_tree">parent</a>).</dd>
<dt><span class="glosskey" id="child_class">child class</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a <a href="#class">class</a> derived from another class (called the <a href="#parent_class">parent class</a>).</dd>
<dt><span class="glosskey" id="circular_dependency">circular dependency</span></dt>
<dd>A situation in which X depends on Y and Y depends on X, either directly or indirectly. If there is a circular dependency, then the <a href="#dependency_graph">dependency graph</a> is not <a href="#dag">acyclic</a>.</dd>
<dt><span class="glosskey" id="class">class</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a structure that combines data and operations (called <a href="#method">methods</a>). The program then uses a <a href="#constructor">constructor</a> to create an <a href="#object">object</a> with those properties and methods. Programmers generally put generic or reusable behavior in <a href="#parent_class">parent classes</a>, and more detailed or specific behavior in <a href="#child_class">child classes</a>.</dd>
<dt><span class="glosskey" id="client">client</span></dt>
<dd>A program such as a web browser that gets data from a <a href="#server">server</a> and displays it to, or interacts with, users. The term is used more generally to refer to any program A that makes requests of another program B. A single program can be both a client and a server.</dd>
<dt><span class="glosskey" id="closure">closure</span></dt>
<dd>A set of variables defined in the same <a href="#scope">scope</a> whose existence has been preserved after that scope has ended.</dd>
<dt><span class="glosskey" id="code_coverage">code coverage (in testing)</span></dt>
<dd>How much of a <a href="#library">library</a> or program is executed when tests run. This is normally reported as a percentage of lines of code.</dd>
<dt><span class="glosskey" id="cognitive_load">cognitive load</span></dt>
<dd>The amount of working memory needed to accomplish a set of simultaneous tasks.</dd>
<dt><span class="glosskey" id="collision">collision</span></dt>
<dd>A situation in which a program tries to store two items in the same location in memory. For example, a collision occurs when a <a href="#hash_function">hash function</a> generates the same <a href="#hash_code">hash code</a> for two different items.</dd>
<dt><span class="glosskey" id="column_major">column-major storage</span></dt>
<dd>Storing each column of a two-dimensional array as one block of memory so that elements in the same row are far apart.
<br/>See also: <a href="#row_major">row-major storage</a>.</dd>
<dt><span class="glosskey" id="combinatorial_explosion">combinatorial explosion</span></dt>
<dd>The exponential growth in the size of a problem or the time required to solve it that arises when all possible combinations of a set of items must be searched.</dd>
<dt><span class="glosskey" id="csv">comma-separated values</span> (CSV)</dt>
<dd>A text format for tabular data in which each <a href="#record">record</a> is one row and <a href="#field">fields</a> are separated by commas. There are many minor variations, particularly around quoting of <a href="#string">strings</a>.</dd>
<dt><span class="glosskey" id="command_line_argument">command-line argument</span></dt>
<dd>A filename or control flag given to a command-line program when it is run.</dd>
<dt><span class="glosskey" id="cli">command-line interface</span> (CLI)</dt>
<dd>A user interface that relies solely on text for commands and output, typically running in a <a href="#shell">shell</a>.</dd>
<dt><span class="glosskey" id="comment">comment</span></dt>
<dd>Text written in a script that is not treated as code to be run, but rather as text that describes what the code is doing. These are usually short notes, often beginning with a <code>#</code> (in many programming languages).</dd>
<dt><span class="glosskey" id="compile">compile</span></dt>
<dd>To translate textual source into another form. Programs in <a href="#compiled_language">compiled languages</a> are translated into machine instructions for a computer to run, and <a href="#markdown">Markdown</a> is usually translated into <a href="#html">HTML</a> for display.</dd>
<dt><span class="glosskey" id="compiled_language">compiled language</span></dt>
<dd>Originally, a language such as C or Fortran that is translated into machine instructions for execution. Languages such as Java are also compiled before execution, but into <a href="#byte_code">byte code</a> instead of machine instructions, while <a href="#interpreted_language">interpreted languages</a> like JavaScript are compiled to byte code on the fly.</dd>
<dt><span class="glosskey" id="compiler">compiler</span></dt>
<dd>An application that translates programs written in some languages into machine instructions or <a href="#byte_code">byte code</a>.</dd>
<dt><span class="glosskey" id="confirmation_bias">confirmation bias</span></dt>
<dd>The tendency for someone to look for evidence that they are right rather than searching for reasons why they might be wrong.</dd>
<dt><span class="glosskey" id="console">console</span></dt>
<dd>A computer terminal where a user may enter commands, or a program, such as a shell that simulates such a device.</dd>
<dt><span class="glosskey" id="constructor">constructor</span></dt>
<dd>A function that creates an <a href="#object">object</a> of a particular <a href="#class">class</a>.</dd>
<dt><span class="glosskey" id="utc">Coordinated Universal Time</span> (UTC)</dt>
<dd>The standard time against which all others are defined. UTC is the time at longitude 0°, and is not adjusted for daylight savings. <a href="#timestamp">Timestamps</a> are often reported in UTC so that they will be the same no matter what timezone the computer is in.</dd>
<dt><span class="glosskey" id="corner_case">corner case</span></dt>
<dd>Another name for an <a href="#edge_case">edge case</a>.</dd>
<dt><span class="glosskey" id="coupling">coupling</span></dt>
<dd>The degree of interaction between two <a href="#class">classes</a>, <a href="#module">modules</a>, or other software components. If a system's components are <a href="#loosely_coupled">loosely coupled</a>, changes to one are unlikely to affect others.  If they are <a href="#tightly_coupled">tightly coupled</a>, then any change requires other changes elsewhere, which complicates maintenance and evolution.</dd>
<dt><span class="glosskey" id="cryptographic_hash_function">cryptographic hash function</span></dt>
<dd>A <a href="#hash_function">hash function</a> that produces an apparently-random value for any input.</dd>
<dt><span class="glosskey" id="current_working_directory">current working directory</span></dt>
<dd>The <a href="#folder">folder</a> or <a href="#directory">directory</a> location in which the program operates. Any action taken by the program occurs relative to this directory.</dd>
<dt><span class="glosskey" id="cycle">cycle (in a graph)</span></dt>
<dd>A set of links in a graph that leads from a node back to itself.</dd>
<dt><span class="glosskey" id="data_frame">data frame</span></dt>
<dd>A two-dimensional data structure for storing tabular data in memory. Rows represent <a href="#record">records</a> and columns represent <a href="#field">fields</a>.</dd>
<dt><span class="glosskey" id="data_migration">data migration</span></dt>
<dd>Moving data from one location or format to another. The term refers to translating data from an old format to a newer one.</dd>
<dt><span class="glosskey" id="decorator_pattern">Decorator pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> in which a function adds additional features to another function or a <a href="#class">class</a> after its initial definition. Decorators are a feature of Python and can be implemented in most other languages as well.</dd>
<dt><span class="glosskey" id="defensive_programming">defensive programming</span></dt>
<dd>A set of programming practices that assumes mistakes will happen and either reports or corrects them, such as inserting <a href="#assertion">assertions</a> to report situations that are not ever supposed to occur.</dd>
<dt><span class="glosskey" id="dependency">dependency</span></dt>
<dd>See <a href="#prerequisite">prerequisite</a>.</dd>
<dt><span class="glosskey" id="dependency_graph">dependency graph</span></dt>
<dd>A <a href="#directed_graph">directed graph</a> showing how things depend on one another, such as the files to be updated by a <a href="#build_manager">build manager</a>. If the dependency graph is not <a href="#dag">acyclic</a>, the dependencies cannot be resolved.</dd>
<dt><span class="glosskey" id="deprecation">deprecation</span></dt>
<dd>To indicate that while a function, method, or class exists, its use is no longer recommended (for example, because it is going to be phased out in a future release).</dd>
<dt><span class="glosskey" id="depth_first">depth-first</span></dt>
<dd>A search algorithm that explores one possibility all the way to its conclusion before moving on to the next.</dd>
<dt><span class="glosskey" id="derived_class">derived class</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a class that is a direct or indirect extension of a <a href="#base_class">base class</a>.
<br/>See also: <a href="#child_class">child class</a>.</dd>
<dt><span class="glosskey" id="design_by_contract">design by contract</span></dt>
<dd>A style of designing software in which functions specify the <a href="#pre_condition">pre-conditions</a> that must be true in order for them to run and the <a href="#post_condition">post-conditions</a> they guarantee will be true when they return. A function can then be replaced by one with weaker pre-conditions (i.e., it accepts a wider set of input) and/or stronger post-conditions (i.e., it produces a smaller range of output) without breaking anything else.
<br/>See also: <a href="#liskov_substitution_principle">Liskov Substitution Principle</a>.</dd>
<dt><span class="glosskey" id="design_pattern">design pattern</span></dt>
<dd>A recurring pattern in software design that is specific enough to be worth naming, but not so specific that a single best implementation can be provided by a <a href="#library">library</a>.
<br/>See also: <a href="#iterator_pattern">Iterator pattern</a>, <a href="#singleton_pattern">Singleton pattern</a>, <a href="#template_method_pattern">Template Method pattern</a>, <a href="#visitor_pattern">Visitor pattern</a>.</dd>
<dt><span class="glosskey" id="destructuring_assignment">destructuring assignment</span></dt>
<dd>Unpacking values from data structures and assigning them to multiple variables in a single statement.</dd>
<dt><span class="glosskey" id="dictionary">dictionary</span></dt>
<dd>A data structure that allows items to be looked up by value, sometimes called an <a href="#associative_array">associative array</a>. Dictionaries are often implemented using <a href="#hash_table">hash tables</a>.</dd>
<dt><span class="glosskey" id="dag">directed acyclic graph</span> (DAG)</dt>
<dd>A <a href="#directed_graph">directed graph</a> which does not contain any loops (i.e., it is not possible to reach a <a href="#node">node</a> from itself by following edges).</dd>
<dt><span class="glosskey" id="directed_graph">directed graph</span></dt>
<dd>A <a href="#graph">graph</a> whose <a href="#edge">edges</a> have directions.</dd>
<dt><span class="glosskey" id="directory">directory</span></dt>
<dd>A structure in a <a href="#filesystem">filesystem</a> that contains references to other structures, such as files and other directories.</dd>
<dt><span class="glosskey" id="disassembler">disassembler</span></dt>
<dd>A program that translates machine instructions into <a href="#assembly_code">assembly code</a> or some other higher-level language.
<br/>See also: <a href="#assembler">assembler</a>.</dd>
<dt><span class="glosskey" id="doc_comment">doc comment</span></dt>
<dd>A documentation comment (&quot;doc comment&quot; for short) is a specially-formatted comment containing documentation about a piece of code that is embedded in the code itself.</dd>
<dt><span class="glosskey" id="dom">Document Object Model</span> (DOM)</dt>
<dd>A standard, in-memory representation of <a href="#html">HTML</a> and <a href="#xml">XML</a>. Each <a href="#element">element</a> is stored as a <a href="#node">node</a> in a <a href="#tree">tree</a> with a set of named <a href="#attribute">attributes</a>; contained elements are <a href="#child_tree">child nodes</a>.</dd>
<dt><span class="glosskey" id="driver">driver</span></dt>
<dd>A program that runs other programs, or a function that drives all of the other functions in a program.</dd>
<dt><span class="glosskey" id="dynamic_loading">dynamic loading</span></dt>
<dd>To <a href="#import">import</a> a <a href="#module">module</a> into the memory of a program while it is already running. Most <a href="#interpreted_language">interpreted languages</a> use dynamic loading, and provide tools so that programs can find and load modules dynamically to configure themselves.</dd>
<dt><span class="glosskey" id="dynamic_lookup">dynamic lookup</span></dt>
<dd>To find a function or a property of an <a href="#object">object</a> by name while a program is running. For example, instead of getting a specific property of an object using <code>obj.name</code>, a program might use <code>obj[someVariable]</code>, where <code>someVariable</code> could hold <code>&quot;name&quot;</code> or some other property name.</dd>
<dt><span class="glosskey" id="dynamic_scoping">dynamic scoping</span></dt>
<dd>To find the value of a variable by looking at what is on the <a href="#call_stack">call stack</a> at the moment the lookup is done. Almost all programming languages use <a href="#lexical_scoping">lexical-scoping</a> instead, since it is more predictable.</dd>
<dt><span class="glosskey" id="eager_matching">eager matching</span></dt>
<dd>Matching as much as possible, as early as possible.</dd>
<dt><span class="glosskey" id="easy_mode">easy mode</span></dt>
<dd>A term borrowed from gaming meaning to do something with obstacles or difficulties simplified or removed, often for practice purposes.</dd>
<dt><span class="glosskey" id="edge">edge</span></dt>
<dd>A connection between two <a href="#node">nodes</a> in a <a href="#graph">graph</a>. An edge may have data associated with it, such as a name or distance.</dd>
<dt><span class="glosskey" id="edge_case">edge case</span></dt>
<dd>A problem that only comes up under unusual circumstances or when a system is pushed to its limits; also sometimes called a <a href="#corner_case">corner case</a>. Programs intended for widespread use have to handle edge cases, but doing so can make them much more complicated.</dd>
<dt><span class="glosskey" id="element">element</span></dt>
<dd>A named component in an <a href="#html">HTML</a> or <a href="#xml">XML</a> document. Elements are usually written <code>&lt;name&gt;</code>…<code>&lt;/name&gt;</code>, where &quot;…&quot; represents the content of the element. Elements often have <a href="#attribute">attributes</a>.</dd>
<dt><span class="glosskey" id="encapsulate">encapsulate</span></dt>
<dd>To store data inside some kind of structure so that it is only accessible through that structure.</dd>
<dt><span class="glosskey" id="entry_point">entry point</span></dt>
<dd>Where a program begins executing.</dd>
<dt><span class="glosskey" id="environment">environment</span></dt>
<dd>A structure that stores a set of variable names and the values they refer to.</dd>
<dt><span class="glosskey" id="error_test">error (in a test)</span></dt>
<dd>Signalled when something goes wrong in a <a href="#unit_test">unit test</a> itself rather than in the system being tested. In this case, we do not know anything about the correctness of the system.</dd>
<dt><span class="glosskey" id="error_handling">error handling</span></dt>
<dd>What a program does to detect and correct for errors. Examples include printing a message and using a default configuration if the user-specified configuration cannot be found.</dd>
<dt><span class="glosskey" id="event_loop">event loop</span></dt>
<dd>A mechanism for managing concurrent activities in a program. Tasks are represented as items in a queue; the event loop repeatedly takes an item from the front of the queue and runs it, adding any other tasks it generates to the back of the queue to run later.</dd>
<dt><span class="glosskey" id="exception">exception</span></dt>
<dd>An object that stores information about an error or other unusual event in a program. One part of a program will create and <a href="#raise_exception">raise an exception</a> to signal that something unexpected has happened; another part will <a href="#catch_exception">catch</a> it.</dd>
<dt><span class="glosskey" id="exception_handler">exception handler</span></dt>
<dd>A piece of code that deals with an <a href="#exception">exception</a> after it is <a href="#catch_exception">caught</a>, e.g., by recording a message, retrying the operation that failed, or performing an alternate operation.</dd>
<dt><span class="glosskey" id="expected_result">expected result (of test)</span></dt>
<dd>The value that a piece of software is supposed to produce when tested in a certain way, or the state in which it is supposed to leave the system.
<br/>See also: <a href="#actual_result">actual result (of test)</a>.</dd>
<dt><span class="glosskey" id="exploratory_programming">exploratory programming</span></dt>
<dd>A software development methodology in which requirements emerge or change as the software is being written, often in response to results from early runs.</dd>
<dt><span class="glosskey" id="export">export</span></dt>
<dd>To make something visible outside a <a href="#module">module</a> so that other parts of a program can <a href="#import">import</a> it. In most languages a module must export things explicitly in an attempt to avoid <a href="#name_collision">name collision</a>.</dd>
<dt><span class="glosskey" id="fail_test">fail (a test)</span></dt>
<dd>A test fails if the <a href="#actual_result">actual result</a> does not match the <a href="#expected_result">expected result</a>.
<br/>See also: <a href="#pass_test">pass (a test)</a>.</dd>
<dt><span class="glosskey" id="feature_software">feature (in software)</span></dt>
<dd>Some aspect of software that was deliberately designed or built. A <a href="#bug">bug</a> is an undesired feature.</dd>
<dt><span class="glosskey" id="field">field</span></dt>
<dd>A component of a <a href="#record">record</a> containing a single value. Every record in a database <a href="#table">table</a> has the same fields.</dd>
<dt><span class="glosskey" id="filename_extension">filename extension</span></dt>
<dd>The last part of a filename, usually following the '.' symbol. Filename extensions are commonly used to indicate the type of content in the file, though there is no guarantee that this is correct.</dd>
<dt><span class="glosskey" id="filesystem">filesystem</span></dt>
<dd>The part of the <a href="#operating_system">operating system</a> that manages how files are stored and retrieved. Also used to refer to all of those files and <a href="#directory">directories</a> or the specific way they are stored (as in &quot;the Unix filesystem&quot;).</dd>
<dt><span class="glosskey" id="filter">filter</span></dt>
<dd>As a verb, to choose a set of <a href="#record">records</a> (i.e., rows of a table) based on the values they contain. As a noun, a command-line program that reads lines of text from files or <a href="#stdin">standard input</a>, performs some operation on them (such as filtering), and writes to a file or <a href="#stdout">stdout</a>.</dd>
<dt><span class="glosskey" id="fsm">finite state machine</span> (FSM)</dt>
<dd>A theoretical model of computing consisting of a directed graph whose nodes represent the states of the computation and whose arcs show how to move from one state to another. Every <a href="#regular_expression">regular expression</a> corresponds to a finite state machine.</dd>
<dt><span class="glosskey" id="fixed_width_string">fixed-width (of strings)</span></dt>
<dd>A set of character strings that have the same length. Databases often used fixed-width strings to make storage and access more efficient; short strings are <a href="#pad_string">padded</a> up to the required length and long strings are truncated.</dd>
<dt><span class="glosskey" id="fixture">fixture</span></dt>
<dd>The thing on which a test is run, such as the <a href="#parameter">parameters</a> to the function being tested or the file being processed.</dd>
<dt><span class="glosskey" id="fluent_interface">fluent interface</span></dt>
<dd>A style of object-oriented programming in which methods return objects so that other methods can immediately be called.</dd>
<dt><span class="glosskey" id="folder">folder</span></dt>
<dd>Another term for a <a href="#directory">directory</a>.</dd>
<dt><span class="glosskey" id="formal_verification">formal verification</span></dt>
<dd>Proving the correctness of an algorithm, program, or piece of hardware using mathematical techniques.</dd>
<dt><span class="glosskey" id="garbage_collection">garbage collection</span></dt>
<dd>The process of identifying memory that has been allocated but is no longer in use and reclaiming it to be re-used.</dd>
<dt><span class="glosskey" id="generator_function">generator function</span></dt>
<dd>A function whose state is automatically saved when it returns a value so that execution can be restarted from that point the next time it is called. One example of generator functions use is to produce streams of values that can be processed by <code>for</code> loops.
<br/>See also: <a href="#iterator_pattern">Iterator pattern</a>.</dd>
<dt><span class="glosskey" id="generic_function">generic function</span></dt>
<dd>A collection of functions with similar purpose, each operating on a different class of data.</dd>
<dt><span class="glosskey" id="global_variable">global variable</span></dt>
<dd>A variable defined outside any particular function or <a href="#package">package</a> namespace, which is therefore visible to all functions.
<br/>See also: <a href="#local_variable">local variable</a>.</dd>
<dt><span class="glosskey" id="globbing">globbing</span></dt>
<dd>To specify a set of filenames using a simplified form of <a href="#regular_expression">regular expressions</a>, such as <code>*.dat</code> to mean &quot;all files whose names end in <code>.dat</code>&quot;. The name is derived from &quot;global&quot;.</dd>
<dt><span class="glosskey" id="graph">graph</span></dt>
<dd>A plot or a chart that displays data, or a data structure in which <a href="#node">nodes</a> are connected to one another by <a href="#edge">edges</a>.
<br/>See also: <a href="#tree">tree</a>.</dd>
<dt><span class="glosskey" id="greedy_algorithm">greedy algorithm</span></dt>
<dd>An algorithm that consumes as much input as possible, as early as possible.</dd>
<dt><span class="glosskey" id="handler">handler</span></dt>
<dd>A <a href="#callback">callback function</a> responsible for handling some particular event, such as the user clicking on a button or new data being receiving from a file.</dd>
<dt><span class="glosskey" id="hash_code">hash code</span></dt>
<dd>A value generated by a <a href="#hash_function">hash function</a>. Good hash codes have the same properties as random numbers in order to reduce the frequency of <a href="#collision">collisions</a>.</dd>
<dt><span class="glosskey" id="hash_function">hash function</span></dt>
<dd>A function that turns arbitrary data into a bit array, or a <a href="#key">key</a>, of a fixed size. Hash functions are used to determine where data should be stored in a <a href="#hash_table">hash table</a>.</dd>
<dt><span class="glosskey" id="hash_table">hash table</span></dt>
<dd>A data structure that calculates a pseudo-random key (location) for each value passed to it and stores the value in that location. Hash tables enable fast lookup for arbitrary data. This occurs at the cost of extra memory because hash tables must always be larger than the amount of information they need to store, to avoid the possibility of data collisions, when the hash function returns the same key for two different values.</dd>
<dt><span class="glosskey" id="header_file">header file</span></dt>
<dd>In C and C++, a file that defines constants and function <a href="#signature">signatures</a> but does not contain runnable code. Header files tell the including file what is defined in other files so that the compiler can generate correct code.</dd>
<dt><span class="glosskey" id="heterogeneous">heterogeneous</span></dt>
<dd>Containing mixed data types. For example, an array in Javascript can contain a mix of numbers, character strings, and values of other types.
<br/>See also: <a href="#homogeneous">homogeneous</a>.</dd>
<dt><span class="glosskey" id="heuristic">heuristic</span></dt>
<dd>A rule or guideline that isn't guaranteed to produce the desired result, but usually does.</dd>
<dt><span class="glosskey" id="homogeneous">homogeneous</span></dt>
<dd>Containing a single data type. For example, a <a href="#vector">vector</a> must be homogeneous: its values must all be numeric, logical, etc.
<br/>See also: <a href="#heterogeneous">heterogeneous</a>.</dd>
<dt><span class="glosskey" id="http_request">HTTP request</span></dt>
<dd>A message sent from a <a href="#client">client</a> to a <a href="#server">server</a> using the <a href="#http">HTTP</a> <a href="#protocol">protocol</a> asking for data. A request usually asks for a web page, image, or other data.
<br/>See also: <a href="#http_response">HTTP response</a>.</dd>
<dt><span class="glosskey" id="http_response">HTTP response</span></dt>
<dd>A reply sent from a <a href="#server">server</a> to a <a href="#client">client</a> using the <a href="#http">HTTP</a> <a href="#protocol">protocol</a> in response to a <a href="#http_request">request</a>. The response usually contains a web page, image, or data.</dd>
<dt><span class="glosskey" id="html">HyperText Markup Language</span> (HTML)</dt>
<dd>The standard <a href="#markup_language">markup language</a> used for web pages. HTML is represented in memory using <a href="#dom">DOM</a> (Digital Object Model).
<br/>See also: <a href="#xml">XML</a>.</dd>
<dt><span class="glosskey" id="http">HyperText Transfer Protocol</span> (HTTP)</dt>
<dd>The standard <a href="#protocol">protocol</a> for data transfer on the World-Wide Web. HTTP defines the format of <a href="#http_request">requests</a> and <a href="#http_response">responses</a>, the meanings of standard error codes, and other features.</dd>
<dt><span class="glosskey" id="idiomatic">idiomatic</span></dt>
<dd>To use a language in the same way as a fluent or native speaker. Programs are called idiomatic if they use the language the way that proficient programmers use it.</dd>
<dt><span class="glosskey" id="iife">immediately-invoked function expression</span> (IIFE)</dt>
<dd>A function that is invoked once at the point where it is defined.  IIFEs are typically used to create a <a href="#scope">scope</a> to hide some function or variable definitions.</dd>
<dt><span class="glosskey" id="immutable">immutable</span></dt>
<dd>Data that cannot be changed after being created. Immutable data is easier to think about, particularly if data structures are shared between several tasks, but may result in higher memory requirements.</dd>
<dt><span class="glosskey" id="import">import</span></dt>
<dd>To bring things from a <a href="#module">module</a> into a program for use. In most languages a program can only import things that the module explicitly <a href="#export">exports</a>.</dd>
<dt><span class="glosskey" id="index_database">index (in a database)</span></dt>
<dd>An auxiliary data structure in a database used to speed up search for some entries. An index increases memory and disk requirements but reduces search time.</dd>
<dt><span class="glosskey" id="inner_function">inner function</span></dt>
<dd>A function defined inside another (outer) function.  Creating and returning inner functions is a way to create <a href="#closure">closures</a>.</dd>
<dt><span class="glosskey" id="instance">instance</span></dt>
<dd>An <a href="#object">object</a> of a particular <a href="#class">class</a>.</dd>
<dt><span class="glosskey" id="instruction_pointer">instruction pointer</span></dt>
<dd>A special <a href="#register">register</a> in a processor that stores the address of the next instruction to execute.</dd>
<dt><span class="glosskey" id="instruction_set">instruction set</span></dt>
<dd>The basic operations that a particular processor can execute directly.</dd>
<dt><span class="glosskey" id="interpreted_language">interpreted language</span></dt>
<dd>A high-level language that is not executed directly by the computer, but instead is run by an <a href="#interpreter">interpreter</a> that translates program instructions into machine commands on the fly.</dd>
<dt><span class="glosskey" id="interpreter">interpreter</span></dt>
<dd>A program whose job it is to run programs written in a high-level <a href="#interpreted_language">interpreted language</a>. Interpreters can run interactively, but may also execute commands saved in a file.</dd>
<dt><span class="glosskey" id="intrinsic_complexity">intrinsic complexity</span></dt>
<dd>The unavoidable complexity inherent in a problem that any solution must deal with. The term is used in contrast with <a href="#accidental_complexity">accidental complexity</a>.</dd>
<dt><span class="glosskey" id="introspection">introspection</span></dt>
<dd>Having a program examine itself as it is running; common examples are to determine the specific class of a generic object or to get the fields of an object when they are not known in advance.</dd>
<dt><span class="glosskey" id="iso_date_format">ISO date format</span></dt>
<dd>An international for formatting dates. While the full standard is complex, the most common form is <code>YYYY-MM-DD</code>, i.e., a four-digit year, a two-digit month, and a two-digit day, separated by hyphens.</dd>
<dt><span class="glosskey" id="iterator_pattern">Iterator pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> in which a temporary <a href="#object">object</a> or <a href="#generator_function">generator function</a> produces each value from a collection in turn for processing. This pattern hides the differences between different kinds of data structures so that everything can be processed using loops.
<br/>See also: <a href="#visitor_pattern">Visitor pattern</a>.</dd>
<dt><span class="glosskey" id="json">JavaScript Object Notation</span> (JSON)</dt>
<dd>A way to represent data by combining basic values like numbers and character strings in <a href="#list">lists</a> and <a href="#dictionary">key/value</a> structures. The acronym stands for &quot;JavaScript Object Notation&quot;; unlike better-defined standards like <a href="#xml">XML</a>, it is unencumbered by a syntax for comments or ways to define a <a href="#schema">schema</a>.
<br/>See also: <a href="#yaml">YAML</a>.</dd>
<dt><span class="glosskey" id="join">join</span></dt>
<dd>An operation that combines two <a href="#table">tables</a>, typically by matching <a href="#key">keys</a> from one with keys from another.</dd>
<dt><span class="glosskey" id="key">key</span></dt>
<dd>A <a href="#field">field</a> or combination of fields whose value(s) uniquely identify a <a href="#record">record</a> within a <a href="#table">table</a> or dataset. Keys are often used to select specific records and in <a href="#join">joins</a>.</dd>
<dt><span class="glosskey" id="label_address">label (address in memory)</span></dt>
<dd>A human-readable name given to a particular location in memory when writing programs in <a href="#assembly_code">assembly code</a>.</dd>
<dt><span class="glosskey" id="layout_engine">layout engine</span></dt>
<dd>A piece of software that decides where to place text, images, and other elements on a page.</dd>
<dt><span class="glosskey" id="lazy_matching">lazy matching</span></dt>
<dd>Matching as little as possible while still finding a valid match.
<br/>See also: <a href="#eager_matching">eager matching</a>.</dd>
<dt><span class="glosskey" id="lru_cache">Least Recently Used cache</span> (LRU cache)</dt>
<dd>A <a href="#cache">cache</a> that discards items that have not been used recently in order to limit memory requirements.</dd>
<dt><span class="glosskey" id="lexical_scoping">lexical scoping</span></dt>
<dd>To look up the value associated with a name according to the textual structure of a program. Most programming languages use lexical scoping instead of <a href="#dynamic_scoping">dynamic scoping</a> because the latter is less predictable.</dd>
<dt><span class="glosskey" id="library">library</span></dt>
<dd>An installable collection of software, also often called a <a href="#module">module</a> or <a href="#package">package</a>.</dd>
<dt><span class="glosskey" id="lifecycle">lifecycle</span></dt>
<dd>The steps that something is allowed or required to go through. The lifecycle of an <a href="#object">object</a> runs from its <a href="#constructor">construction</a> through the operations it can or must perform before it is destroyed.</dd>
<dt><span class="glosskey" id="line_comment">line comment</span></dt>
<dd>A <a href="#comment">comment</a> in a program that spans part of a single line, as opposed to a <a href="#block_comment">block comment</a> that may span multiple lines.</dd>
<dt><span class="glosskey" id="link">link (a program)</span></dt>
<dd>To combine separately <a href="#compile">compiled</a> modules into a single runnable program.</dd>
<dt><span class="glosskey" id="linter">linter</span></dt>
<dd>A program that checks for common problems in software, such as violations of indentation rules or variable naming conventions. The name comes from the first tool of its kind, called <code>lint</code>.</dd>
<dt><span class="glosskey" id="liskov_substitution_principle">Liskov Substitution Principle</span></dt>
<dd>A design rule stating that it should be possible to replace objects in a program with objects of derived classes without breaking the program. <a href="#design_by_contract">Design by contract</a> is intended to enforce this rule.</dd>
<dt><span class="glosskey" id="list">list</span></dt>
<dd>A <a href="#vector">vector</a> that can contain values of many different (<a href="#heterogeneous">heterogeneous</a>) types.</dd>
<dt><span class="glosskey" id="literal">literal</span></dt>
<dd>A representation of a fixed value in a program, such as the digits <code>123</code> for the number 123 or the characters <code>&quot;abc&quot;</code> for the string containing those three letters.</dd>
<dt><span class="glosskey" id="literate_programming">literate programming</span></dt>
<dd>A programming paradigm that mixes prose and code so that explanations and instructions are side by side.</dd>
<dt><span class="glosskey" id="loader">loader</span></dt>
<dd>A function whose job is to read files containing runnable code into memory and make that code available to the calling program.</dd>
<dt><span class="glosskey" id="local_variable">local variable</span></dt>
<dd>A variable defined inside a function which is only visible within that function.
<br/>See also: <a href="#closure">closure</a>, <a href="#global_variable">global variable</a>.</dd>
<dt><span class="glosskey" id="log_message">log message</span></dt>
<dd>A status report or error message written to a file as a program runs.</dd>
<dt><span class="glosskey" id="loop_body">loop body</span></dt>
<dd>The statement or statements executed by a loop.</dd>
<dt><span class="glosskey" id="loosely_coupled">loosely coupled</span></dt>
<dd>Components in a software system are said to be loosely coupled if they are relatively independent of one another, i.e., if any one of them can be changed or replaced without others having to be altered as well.
<br/>See also: <a href="#tightly_coupled">tightly coupled</a>.</dd>
<dt><span class="glosskey" id="macro">macro</span></dt>
<dd>Originally short for &quot;macro-instruction&quot;, an instruction to translate some of the text into a program into other text before using it.</dd>
<dt><span class="glosskey" id="makefile">Makefile</span></dt>
<dd>A configuration file for the original <a href="#build_manager">build manager</a>.</dd>
<dt><span class="glosskey" id="manifest">manifest</span></dt>
<dd>A list that specifies the precise versions of a complete set of libraries or other software components.</dd>
<dt><span class="glosskey" id="markdown">Markdown</span></dt>
<dd>A <a href="#markup_language">markup language</a> with a simple syntax intended as a replacement for <a href="#html">HTML</a>.</dd>
<dt><span class="glosskey" id="markup_language">markup language</span></dt>
<dd>A set of rules for annotating text to define its meaning or how it should be displayed. The markup is usually not displayed, but instead controls how the underlying text is interpreted or shown. <a href="#markdown">Markdown</a> and <a href="#html">HTML</a> are widely-used markup languages for web pages.
<br/>See also: <a href="#xml">XML</a>.</dd>
<dt><span class="glosskey" id="method">method</span></dt>
<dd>An implementation of a <a href="#generic_function">generic function</a> that handles objects of a specific class.</dd>
<dt><span class="glosskey" id="method_chaining">method chaining</span></dt>
<dd>A style of object-oriented programming in which an object's methods return that object as their result so that another method can immediately be called, as in <code>obj.a().b().c()</code>.</dd>
<dt><span class="glosskey" id="mock_object">mock object</span></dt>
<dd>A simplified replacement for part of a program whose behavior is easy to control and predict. Mock objects are used in <a href="#unit_test">unit tests</a> to simulate databases, web services, and other complex systems.</dd>
<dt><span class="glosskey" id="module">module</span></dt>
<dd>A reusable software <a href="#package">package</a>, also often called a <a href="#library">library</a>.</dd>
<dt><span class="glosskey" id="module_bundler">module bundler</span></dt>
<dd>A program that finds all the dependencies of a set of source files and combines them into a single loadable file.</dd>
<dt><span class="glosskey" id="multi_threaded">multi-threaded</span></dt>
<dd>Capable of performing several operations simultaneously. Multi-threaded programs are usually more efficient than <a href="#single_threaded">single-threaded</a> ones, but also harder to understand and debug.</dd>
<dt><span class="glosskey" id="name_collision">name collision</span></dt>
<dd>The ambiguity that arises when two or more things in a program that have the same name are active at the same time. Most languages use <a href="#namespace">namespaces</a> to prevent such collisions.
<br/>See also: <a href="#call_stack">call stack</a>.</dd>
<dt><span class="glosskey" id="namespace">namespace</span></dt>
<dd>A collection of names in a program that exists in isolation from other namespaces. Each function, <a href="#object">object</a>, <a href="#class">class</a>, or <a href="#module">module</a> in a program typically has its own namespace so that references to &quot;X&quot; in one part of a program do not accidentally refer to something called &quot;X&quot; in another part of the program. Scope is a distinct, but related, concept.
<br/>See also: <a href="#name_collision">name collision</a>, <a href="#scope">scope</a>.</dd>
<dt><span class="glosskey" id="nested_function">nested function</span></dt>
<dd>A function that is defined inside another function.</dd>
<dt><span class="glosskey" id="node">node</span></dt>
<dd>An element of a <a href="#graph">graph</a> that is connected to other nodes by <a href="#edge">edges</a>. Nodes typically have data associated with them, such as names or weights.</dd>
<dt><span class="glosskey" id="non_blocking_execution">non-blocking execution</span></dt>
<dd>To allow a program to continue running while an operation is in progress. For example, many systems support non-blocking execution for file I/O so that the program can continue doing work while it waits for data to be read from or written to the <a href="#filesystem">filesystem</a> (which is typically much slower than the CPU).</dd>
<dt><span class="glosskey" id="object">object</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, a structure that contains the data for a specific instance of a <a href="#class">class</a>. The operations the object is capable of are defined by the class's <a href="#method">methods</a>.</dd>
<dt><span class="glosskey" id="oop">object-oriented programming</span> (OOP)</dt>
<dd>A style of programming in which functions and data are bound together in <a href="#object">objects</a> that only interact with each other through well-defined interfaces.</dd>
<dt><span class="glosskey" id="off_by_one_error">off-by-one error</span></dt>
<dd>A common error in programming in which the program refers to element <code>i</code> of a structure when it should refer to element <code>i-1</code> or <code>i+1</code>, or processes <code>N</code> elements when it should process <code>N-1</code> or <code>N+1</code>.</dd>
<dt><span class="glosskey" id="op_code">op code</span></dt>
<dd>The numerical code for a particular instruction that a processor can execute.</dd>
<dt><span class="glosskey" id="open_closed_principle">Open-Closed Principle</span></dt>
<dd>A design rule stating that software should be open for extension but closed for modification, i.e., it should be possible to extend functionality without having to rewrite existing code.</dd>
<dt><span class="glosskey" id="operating_system">operating system</span></dt>
<dd>A program that provides a standard interface to whatever hardware it is running on. Theoretically, any program that only interacts with the operating system should run on any computer that operating system runs on.</dd>
<dt><span class="glosskey" id="package">package</span></dt>
<dd>A collection of code, data, and documentation that can be distributed and re-used. Also referred to in some languages as a <a href="#library">library</a> or <a href="#module">module</a>.</dd>
<dt><span class="glosskey" id="pad_string">pad (a string)</span></dt>
<dd>To add extra characters to a string to make it a required length.</dd>
<dt><span class="glosskey" id="parameter">parameter</span></dt>
<dd>A variable specified in a function definition that is assigned a value when the function is called.
<br/>See also: <a href="#argument">argument</a>.</dd>
<dt><span class="glosskey" id="parent_tree">parent (in a tree)</span></dt>
<dd>A <a href="#node">node</a> in a <a href="#node">tree</a> that is above another node (called a <a href="#child_tree">child</a>). Every node in a tree except the <a href="#root_tree">root node</a> has a single parent.</dd>
<dt><span class="glosskey" id="parent_class">parent class</span></dt>
<dd>In <a href="#oop">object-oriented programming</a>, the <a href="#class">class</a> from which a sub class (called the <a href="#child_class">child class</a>) is derived.</dd>
<dt><span class="glosskey" id="parser">parser</span></dt>
<dd>A piece of software that translates a textual representation of something into a data structure. For example, a <a href="#yaml">YAML</a> parser reads indented text and produces nested lists and objects.</dd>
<dt><span class="glosskey" id="pass_test">pass (a test)</span></dt>
<dd>A test passes if the <a href="#actual_result">actual result</a> matches the <a href="#expected_result">expected result</a>.
<br/>See also: <a href="#fail_test">fail (a test)</a>.</dd>
<dt><span class="glosskey" id="patch">patch</span></dt>
<dd>A single file containing a set of changes to a set of files, separated by markers that indicate where each individual change should be applied.</dd>
<dt><span class="glosskey" id="path">path (in filesystem)</span></dt>
<dd>A <a href="#string">string</a> that specifies a location in a <a href="#filesystem">filesystem</a>. In Unix, the <a href="#directory">directories</a> in a path are joined using <code>/</code>.
<br/>See also: <a href="#absolute_path">absolute path</a>, <a href="#relative_path">relative path</a>.</dd>
<dt><span class="glosskey" id="pattern_rule">pattern rule</span></dt>
<dd>A generic <a href="#build_rule">build rule</a> that describes how to update any file whose name matches a pattern. Pattern rules often use <a href="#automatic_variable">automatic variables</a> to represent the actual filenames.</dd>
<dt><span class="glosskey" id="pipe">pipe</span></dt>
<dd>To use the output of one computation as the input for the next, or the connection between the two computations responsible for the data transfer. Pipes were popularized by the <a href="#shell">Unix shell</a>, and are now used in many different programming languages and systems.</dd>
<dt><span class="glosskey" id="pipe_shell">pipe (in the Unix shell)</span></dt>
<dd>The <code>|</code> used to make the output of one command the input of the next.</dd>
<dt><span class="glosskey" id="plugin_architecture">plugin architecture</span></dt>
<dd>A style of application design in which the main program loads and runs small independent modules that do the bulk of the work.</dd>
<dt><span class="glosskey" id="polymorphism">polymorphism</span></dt>
<dd>Having many different implementations of the same interface. If a set of functions or objects are polymorphic, they can be called interchangeably.</dd>
<dt><span class="glosskey" id="post_condition">post-condition</span></dt>
<dd>Something that is guaranteed to be true after a function runs successfully. Post-conditions are often expressed as <a href="#assertion">assertions</a> that are guaranteed to be be true of a function's results.
<br/>See also: <a href="#design_by_contract">design by contract</a>, <a href="#pre_condition">pre-condition</a>.</dd>
<dt><span class="glosskey" id="pre_condition">pre-condition</span></dt>
<dd>Something that must be true before a function runs in order for it to work correctly. Pre-conditions are often expressed as as <a href="#assertion">assertions</a> that must be true of a function's inputs in order for it to run successfully.
<br/>See also: <a href="#design_by_contract">design by contract</a>, <a href="#post_condition">post-condition</a>.</dd>
<dt><span class="glosskey" id="precedence">precedence</span></dt>
<dd>The priority of an operation. For example, multiplication has a higher precedence than addition, so <code>a+b*c</code> is read as &quot;the sum of <code>a</code> with the product of <code>b</code> and <code>c</code>&quot;.</dd>
<dt><span class="glosskey" id="prerequisite">prerequisite</span></dt>
<dd>Something that a <a href="#build_target">build target</a> depends on.
<br/>See also: <a href="#dependency">dependency</a>.</dd>
<dt><span class="glosskey" id="process">process</span></dt>
<dd>An <a href="#operating_system">operating system</a>'s representation of a running program. A process typically has some memory, the identity of the user who is running it, and a set of connections to open files.</dd>
<dt><span class="glosskey" id="promise">promise</span></dt>
<dd>A way to represent the result of a delayed or <a href="#asynchronous">asynchronous</a> computation. A promise is a placeholder for a value that will eventually be computed; any attempt to read the value before it is available blocks, while any such attempt after the computation finishes acts like a normal read.
<br/>See also: <a href="#promisification">promisification</a>.</dd>
<dt><span class="glosskey" id="promisification">promisification</span></dt>
<dd>In JavaScript, the act of wrapping a callback function in a <a href="#promise">promise</a> for uniform asynchronous execution.</dd>
<dt><span class="glosskey" id="protocol">protocol</span></dt>
<dd>Any standard specifying how two pieces of software interact. A network protocol such as <a href="#http">HTTP</a> defines the messages that <a href="#client">clients</a> and <a href="#server">servers</a> exchange on the World-Wide Web; <a href="#oop">object-oriented</a> programs often define protocols for interactions between <a href="#object">objects</a> of different <a href="#class">classes</a>.</dd>
<dt><span class="glosskey" id="prune">prune</span></dt>
<dd>To remove branches and nodes from a tree, or to rule out partially-complete solutions when searching for an overall solution in order to reduce work.</dd>
<dt><span class="glosskey" id="pseudo_random_number">pseudo-random number</span></dt>
<dd>A value generated in a repeatable way that resembles the true randomness of the universe well enough to fool observers.</dd>
<dt><span class="glosskey" id="prng">pseudo-random number generator</span> (PRNG)</dt>
<dd>A function that can generate <a href="#pseudo_random_number">pseudo-random numbers</a>.
<br/>See also: <a href="#seed">seed</a>.</dd>
<dt><span class="glosskey" id="query_selector">query selector</span></dt>
<dd>A pattern that specifies a set of <a href="#dom">DOM</a> nodes.  Query selectors are used in <a href="#css">CSS</a> to specify the elements that rules apply to, or by JavaScript programs to manipulate web pages.</dd>
<dt><span class="glosskey" id="query_string">query string</span></dt>
<dd>The portion of a <a href="#url">URL</a> after the question mark <code>?</code> that specifies extra parameters for the <a href="#http_request">HTTP request</a> as name-value pairs.</dd>
<dt><span class="glosskey" id="race_condition">race condition</span></dt>
<dd>A situation in which a result depends on the order in which two or more concurrent operations are carried out.</dd>
<dt><span class="glosskey" id="raise_exception">raise (an exception)</span></dt>
<dd>To signal that something unexpected or unusual has happened in a program by creating an <a href="#exception">exception</a> and handing it to the <a href="#error_handling">error-handling</a> system, which then tries to find a point in the program that will <a href="#catch_exception">catch</a> it.
<br/>See also: <a href="#throw_exception">throw (exception)</a>.</dd>
<dt><span class="glosskey" id="repl">read-eval-print loop</span> (REPL)</dt>
<dd>An interactive program that reads a command typed in by a user, executes it, prints the result, and then waits patiently for the next command. REPLs are often used to explore new ideas, or for debugging.</dd>
<dt><span class="glosskey" id="record">record</span></dt>
<dd>A group of related values that are stored together. A record may be represented as a <a href="#tuple">tuple</a> or as a row in a <a href="#table">table</a>; in the latter case, every record in the table has the same <a href="#field">fields</a>.</dd>
<dt><span class="glosskey" id="register">register</span></dt>
<dd>A small piece of memory (typically one <a href="#word_memory">word</a> long) built into a processor that operations can refer to directly.</dd>
<dt><span class="glosskey" id="regular_expression">regular expression</span></dt>
<dd>A pattern for matching text, written as text itself. Regular expressions are sometimes called &quot;regexp&quot;, &quot;regex&quot;, or &quot;RE&quot;, and are powerful tools for working with text.</dd>
<dt><span class="glosskey" id="relational_database">relational database</span></dt>
<dd>A database that organizes information into <a href="#table">tables</a>, each of which has a fixed set of named <a href="#field">fields</a> (shown as columns) and a variable number of <a href="#record">records</a> (shown as rows).
<br/>See also: <a href="#sql">SQL</a>.</dd>
<dt><span class="glosskey" id="relative_error">relative error</span></dt>
<dd>The absolute value of the difference between the actual and correct value divided by the correct value. For example, if the actual value is 9 and the correct value is 10, the relative error is 0.1. Relative error is usually more useful than <a href="#absolute_error">absolute error</a>.</dd>
<dt><span class="glosskey" id="relative_path">relative path</span></dt>
<dd>A path that is interpreted relative to some other location, such as the <a href="#current_working_directory">current working directory</a>. A relative path is the equivalent of giving directions using terms like &quot;straight&quot; and &quot;left&quot;.
<br/>See also: <a href="#absolute_path">absolute path</a>.</dd>
<dt><span class="glosskey" id="root_tree">root (in a tree)</span></dt>
<dd>The <a href="#node">node</a> in a <a href="#tree">tree</a> of which all other nodes are direct or indirect <a href="#child_tree">children</a>, or equivalently the only node in the tree that has no <a href="#parent_tree">parent</a>.</dd>
<dt><span class="glosskey" id="row_major">row-major storage</span></dt>
<dd>Storing each row of a two-dimensional array as one block of memory so that elements in the same column are far apart.
<br/>See also: <a href="#column_major">column-major storage</a>.</dd>
<dt><span class="glosskey" id="runnable_documentation">runnable documentation</span></dt>
<dd>Statements about code that can be executed to check their correctness, such as <a href="#assertion">assertions</a> or <a href="#type_declaration">type declarations</a>.</dd>
<dt><span class="glosskey" id="sandbox">sandbox</span></dt>
<dd>A testing environment that is separate from the production system, or an environment that is only allowed to perform a restricted set of operations for security reasons.</dd>
<dt><span class="glosskey" id="sat_solver">SAT solver</span></dt>
<dd>A library or application that determines whether there is an assignment of true and false to a set of <a href="#boolean">Boolean</a> variables that makes an expression true (i.e., that satisfies the expression).</dd>
<dt><span class="glosskey" id="schema">schema</span></dt>
<dd>A specification of the format of a dataset, including the name, format, and content of each <a href="#table">table</a>.</dd>
<dt><span class="glosskey" id="scope">scope</span></dt>
<dd>The portion of a program within which a definition can be seen and used.
<br/>See also: <a href="#closure">closure</a>, <a href="#global_variable">global variable</a>, <a href="#local_variable">local variable</a>, <a href="#namespace">namespace</a>.</dd>
<dt><span class="glosskey" id="scope_creep">scope creep</span></dt>
<dd>Slow but steady increase in a project's goals after the project starts.</dd>
<dt><span class="glosskey" id="scoring_function">scoring function</span></dt>
<dd>A function that measures or estimates how good a solution to a problem is.</dd>
<dt><span class="glosskey" id="search_path">search path</span></dt>
<dd>The list of directories that a program searches to find something. For example, the Unix <a href="#shell">shell</a> uses the search path stored in the <code>PATH</code> variable when trying to find a program whose name it has been given.</dd>
<dt><span class="glosskey" id="seed">seed</span></dt>
<dd>A value used to initialize a <a href="#prng">pseudo-random number generator</a>.</dd>
<dt><span class="glosskey" id="semantic_versioning">semantic versioning</span></dt>
<dd>A standard for identifying software releases. In the version identifier <code>major.minor.patch</code>, <code>major</code> changes when a new version of software is incompatible with old versions, <code>minor</code> changes when new features are added to an existing version, and <code>patch</code> changes when small <a href="#bug">bugs</a> are fixed.</dd>
<dt><span class="glosskey" id="server">server</span></dt>
<dd>Typically, a program such as a database manager or web server that provides data to a <a href="#client">client</a> upon request.</dd>
<dt><span class="glosskey" id="sha_1">SHA-1 hash</span></dt>
<dd>A <a href="#cryptographic_hash_function">cryptographic hash function</a> that produces a 160-bit output.</dd>
<dt><span class="glosskey" id="shell">shell</span></dt>
<dd>A <a href="#cli">command-line interface</a> that allows a user to interact with the <a href="#operating_system">operating system</a>, such as Bash (for Unix and MacOS) or PowerShell (for Windows).</dd>
<dt><span class="glosskey" id="shell_variable">shell variable</span></dt>
<dd>A variable set and used in the <a href="#shell">Unix shell</a>. Commonly-used shell variables include <code>HOME</code> (the user's home directory) and <code>PATH</code> (their <a href="#search_path">search path</a>).</dd>
<dt><span class="glosskey" id="side_effect">side effect</span></dt>
<dd>A change made by a function while it runs that is visible after the function finishes, such as modifying a <a href="#global_variable">global variable</a> or writing to a file. Side effects make programs harder for people to understand, since the effects are not necessarily clear at the point in the program where the function is called.</dd>
<dt><span class="glosskey" id="signature">signature</span></dt>
<dd>The set of parameters (with types or meaning) that characterize the calling interface of a function or set of functions. Two functions with the same signature can be called interchangeably.</dd>
<dt><span class="glosskey" id="single_threaded">single-threaded</span></dt>
<dd>A model of program execution in which only one thing can happen at a time. Single-threaded execution is easier for people to understand, but less efficient than <a href="#multi_threaded">multi-threaded</a> execution.</dd>
<dt><span class="glosskey" id="singleton">singleton</span></dt>
<dd>A set with only one element, or a <a href="#class">class</a> with only one <a href="#instance">instance</a>.
<br/>See also: <a href="#singleton_pattern">Singleton pattern</a>.</dd>
<dt><span class="glosskey" id="singleton_pattern">Singleton pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> that creates a <a href="#singleton">singleton</a> <a href="#object">object</a> to manage some resource or service, such as a database or <a href="#cache">cache</a>. In <a href="#oop">object-oriented programming</a>, the pattern is usually implemented by hiding the <a href="#constructor">constructor</a> of the <a href="#class">class</a> in some way so that it can only be called once.</dd>
<dt><span class="glosskey" id="slug">slug</span></dt>
<dd>An abbreviated portion of a page's URL that uniquely identifies it. In the example <code>https://www.mysite.com/category/post-name</code>, the slug is <code>post-name</code>.</dd>
<dt><span class="glosskey" id="source_map">source map</span></dt>
<dd>A table used to translate a piece of code back to the lines in the original source.</dd>
<dt><span class="glosskey" id="sparse_matrix">sparse matrix</span></dt>
<dd>A matrix in which most of the values are zero (or some other value). Rather than storing many copies of the same values, programs will often use a special data structure that only stores the &quot;interesting&quot; values.</dd>
<dt><span class="glosskey" id="sql">SQL</span></dt>
<dd>The language used for writing queries for a <a href="#relational_database">relational database</a>. The term was originally an acronym for Structured Query Language.</dd>
<dt><span class="glosskey" id="stack_frame">stack frame</span></dt>
<dd>A section of the <a href="#call_stack">call stack</a> that records details of a single call to a specific function.</dd>
<dt><span class="glosskey" id="build_stale">stale (in build)</span></dt>
<dd>To be out-of-date compared to a <a href="#prerequisite">prerequisite</a>. A <a href="#build_manager">build manager</a>'s job is to find and update things that are stale.</dd>
<dt><span class="glosskey" id="stderr">standard error</span></dt>
<dd>A predefined communication channel for a <a href="#process">process</a> typically used to report errors.
<br/>See also: <a href="#stdin">standard input</a>, <a href="#stdout">standard output</a>.</dd>
<dt><span class="glosskey" id="stdin">standard input</span></dt>
<dd>A predefined communication channel for a <a href="#process">process</a>, typically used to read input from the keyboard or from the previous process in a <a href="#pipe_shell">pipe</a>.
<br/>See also: <a href="#stderr">standard error</a>, <a href="#stdout">standard output</a>.</dd>
<dt><span class="glosskey" id="stdout">standard output</span></dt>
<dd>A predefined communication channel for a <a href="#process">process</a>, typically used to send output to the screen or to the next process in a <a href="#pipe_shell">pipe</a>.
<br/>See also: <a href="#stderr">standard error</a>, <a href="#stdin">standard input</a>.</dd>
<dt><span class="glosskey" id="static_site_generator">static site generator</span></dt>
<dd>A software tool that creates HTML pages from templates and content.</dd>
<dt><span class="glosskey" id="stream">stream</span></dt>
<dd>A sequential flow of data, such as the <a href="#bit">bits</a> arriving across a network connection or the bytes read from a file.</dd>
<dt><span class="glosskey" id="streaming_api">streaming API</span></dt>
<dd>An <a href="#api">API</a> that processes data in chunks rather than needing to have all of it in memory at once. Streaming APIs usually require <a href="#handler">handlers</a> for events such as &quot;start of data&quot;, &quot;next block&quot;, and &quot;end of data&quot;.</dd>
<dt><span class="glosskey" id="string">string</span></dt>
<dd>A block of text in a program. The term is short for &quot;character string&quot;.</dd>
<dt><span class="glosskey" id="string_interpolation">string interpolation</span></dt>
<dd>The process of inserting text corresponding to specified values into a <a href="#string">string</a>, usually to make output human-readable.</dd>
<dt><span class="glosskey" id="synchronous">synchronous</span></dt>
<dd>To happen at the same time. In programming, synchronous operations are ones that have to run simultaneously, or complete at the same time.
<br/>See also: <a href="#asynchronous">asynchronous</a>.</dd>
<dt><span class="glosskey" id="tab_completion">tab completion</span></dt>
<dd>A technique implemented by most <a href="#repl">REPLs</a>, <a href="#shell">shells</a>, and programming editors that completes a command, variable name, filename, or other text when the TAB key is pressed.</dd>
<dt><span class="glosskey" id="table">table</span></dt>
<dd>A set of <a href="#record">records</a> in a <a href="#relational_database">relational database</a> or <a href="#data_frame">data frame</a>.</dd>
<dt><span class="glosskey" id="tagged_data">tagged data</span></dt>
<dd>A technique for storing data in a two-part structure, where one part identifies the type and the other part stores the bits making up the value.</dd>
<dt><span class="glosskey" id="template_method_pattern">Template Method pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> in which a <a href="#parent_class">parent class</a> defines an overall sequence of operations by calling <a href="#abstract_method">abstract methods</a> that <a href="#child_class">child classes</a> must then implement. Each child class then behaves in the same general way, but implements the steps differently.</dd>
<dt><span class="glosskey" id="test_harness">test harness</span></dt>
<dd>A program written to test some other program or set of functions, typically to measure their performance.</dd>
<dt><span class="glosskey" id="test_runner">test runner</span></dt>
<dd>A program that finds and runs software tests and reports their results.</dd>
<dt><span class="glosskey" id="test_subject">test subject</span></dt>
<dd>The thing being tested, sometimes also called the system under test (SUT).</dd>
<dt><span class="glosskey" id="tdd">test-driven development</span> (TDD)</dt>
<dd>A programming practice in which tests are written before a new feature is added or a <a href="#bug">bug</a> is fixed in order to clarify the goal.</dd>
<dt><span class="glosskey" id="throw_exception">throw (exception)</span></dt>
<dd>Another term for <a href="#raise_exception">raising</a> an exception.</dd>
<dt><span class="glosskey" id="tightly_coupled">tightly coupled</span></dt>
<dd>Components in a software system are said to be tightly coupled if they depend on each other's internals, so that if one is altered then others have to be altered as well.
<br/>See also: <a href="#loosely_coupled">loosely coupled</a>.</dd>
<dt><span class="glosskey" id="toctou">Time of check/time of use</span> (ToCToU)</dt>
<dd>A <a href="#race_condition">race condition</a> in which a process checks the state of something and then operates on it, but some other process might alter that state between the check and the operation.</dd>
<dt><span class="glosskey" id="timestamp">timestamp</span></dt>
<dd>A digital identifier showing the time at which something was created or accessed. Timestamps should use <a href="#iso_date_format">ISO date format</a> for portability.</dd>
<dt><span class="glosskey" id="token">token</span></dt>
<dd>An indivisible unit of text for a parser, such as a variable name or a number. Exactly what constitutes a token depends on the language.</dd>
<dt><span class="glosskey" id="topological_order">topological order</span></dt>
<dd>Any ordering of the <a href="#node">nodes</a> in a <a href="#graph">graph</a> that respects the direction of its <a href="#edge">edges</a>, i.e., if there is an edge from node A to node B, A comes before B in the ordering. There may be many topological orderings of a particular graph.</dd>
<dt><span class="glosskey" id="transitive_closure">transitive closure</span></dt>
<dd>The set of all <a href="#node">nodes</a> in a <a href="#graph">graph</a> that are reachable from a starting node, either directly or indirectly.</dd>
<dt><span class="glosskey" id="tree">tree</span></dt>
<dd>A <a href="#graph">graph</a> in which every node except the <a href="#root_tree">root</a> has exactly one <a href="#parent_tree">parent</a>.</dd>
<dt><span class="glosskey" id="tuple">tuple</span></dt>
<dd>A value that has a fixed number of parts, such as the three color components of a red-green-blue color specification.</dd>
<dt><span class="glosskey" id="turing_machine">Turing Machine</span></dt>
<dd>A theoretical model of computation that manipulates symbols on an infinite tape according to a fixed table of rules. Any computation that can be expressed as an algorithm can be done by a Turing Machine.</dd>
<dt><span class="glosskey" id="two_hard_problems">two hard problems in computer science</span></dt>
<dd>Refers to a quote by Phil Karlton: &quot;There are only two hard problems in computer science—cache invalidation and naming things.&quot; Many variations add a third problem as a joke, such as <a href="#off_by_one_error">off-by-one errors</a>.</dd>
<dt><span class="glosskey" id="type_declaration">type declaration</span></dt>
<dd>A statement in a program that a variable or value has a particular data type. Languages like Java require type declarations for all variables; they are optional in TypeScript and Python, and not allowed in pure JavaScript.</dd>
<dt><span class="glosskey" id="unicode">Unicode</span></dt>
<dd>A standard that defines numeric codes for many thousands of characters and symbols. Unicode does not define how those numbers are stored; that is done by standards like <a href="#utf_8">UTF-8</a>.</dd>
<dt><span class="glosskey" id="url">Uniform Resource Locator</span> (URL)</dt>
<dd>A unique address on the World-Wide Web. URLs originally identified web pages, but may also represent datasets or database queries, particularly if they include a <a href="#query_string">query string</a>.</dd>
<dt><span class="glosskey" id="unit_test">unit test</span></dt>
<dd>A test that exercises one function or feature of a piece of software and produces <a href="#pass_test">pass</a>, <a href="#fail_test">fail</a>, or <a href="#error_test">error</a>.</dd>
<dt><span class="glosskey" id="utf_8">UTF-8</span></dt>
<dd>A way to store the numeric codes representing <a href="#unicode">Unicode</a> characters in memory that is <a href="#backward_compatible">backward-compatible</a> with the older <a href="#ascii">ASCII</a> standard.</dd>
<dt><span class="glosskey" id="vector">vector</span></dt>
<dd>A sequence of values, usually of <a href="#homogeneous">homogeneous</a> type.</dd>
<dt><span class="glosskey" id="version_control_system">version control system</span></dt>
<dd>A system for managing changes made to software during its development.</dd>
<dt><span class="glosskey" id="virtual_machine">virtual machine</span></dt>
<dd>A program that pretends to be a computer. This may seem a bit redundant, but VMs are quick to create and start up, and changes made inside the virtual machine are contained within that VM so we can install new <a href="#package">packages</a> or run a completely different operating system without affecting the underlying computer.</dd>
<dt><span class="glosskey" id="visitor_pattern">Visitor pattern</span></dt>
<dd>A <a href="#design_pattern">design pattern</a> in which the operation to be done is taken to each element of a data structure in turn. It is usually implemented by having a generator &quot;visitor&quot; that knows how to reach the structure's elements, which is given a function or method to call for each in turn, and that carries out the specific operation.
<br/>See also: <a href="#iterator_pattern">Iterator pattern</a>.</dd>
<dt><span class="glosskey" id="walk_tree">walk (a tree)</span></dt>
<dd>To visit each <a href="#node">node</a> in a <a href="#tree">tree</a> in some order, typically <a href="#depth_first">depth-first</a> or <a href="#breadth_first">breadth-first</a>.</dd>
<dt><span class="glosskey" id="watchpoint">watchpoint</span></dt>
<dd>An instruction for a debugger telling it to suspect execution whenever the value of a variable (or more generally an expression) changes.
<br/>See also: <a href="#breakpoint">breakpoint</a>.</dd>
<dt><span class="glosskey" id="well_formed">well formed</span></dt>
<dd>A piece of text that obeys the rules of a formal grammar is said to be well formed.</dd>
<dt><span class="glosskey" id="word_memory">word (of memory)</span></dt>
<dd>The unit of memory that a particular processor most naturally works with. While a byte is a fixed size (8 bits), a word may be 16, 32, or 64 bits long depending on the processor.</dd>
<dt><span class="glosskey" id="xml">XML</span></dt>
<dd>A set of rules for defining <a href="#html">HTML</a>-like tags and using them to format documents (typically data). XML was popular in the early 2000s, but its complexity led many programmers to adopt <a href="#json">JSON</a>, instead.</dd>
<dt><span class="glosskey" id="yaml">YAML</span></dt>
<dd>Short for &quot;YAML Ain't Markup Language&quot;, a way to represent nested data using indentation rather than the parentheses and commas of <a href="#json">JSON</a>. YAML is often used in configuration files and to define <a href="#parameter">parameters</a> for various flavors of <a href="#markdown">Markdown</a> documents.</dd>
<dt><span class="glosskey" id="z_buffering">z-buffering</span></dt>
<dd>A drawing method that keeps track of the depth of what lies &quot;under&quot; each pixel so that it displays whatever is nearest to the observer.</dd>
</dl>

    </main>
    <footer>
  <hr/>
  <p>
    Copyright © 2022 Greg Wilson
    &nbsp;
    <a href="../license/"><img class="icon" src="../static/cc-by-nc.svg" alt="CC-BY-NC icon"/></a>
    <a href="../license/"><img class="icon" src="../static/hippocratic.svg" alt="Hippocratic License icon"/></a>
    <a href="https://github.com/software-tools-books/stjs/"><img class="icon" src="../static/github.svg" alt="GitHub icon"/></a>
    <a href="mailto:gvwilson@third-bit.com"><img class="icon" src="../static/email.svg" alt="email icon"/></a>
  </p>
</footer>

  </body>
</html>
